
#!pip install -r libraries_to_install.txt


import os
import random
import numpy as np
import torch
from torch import nn
from tqdm import tqdm
from pathlib import Path
from statistics import mean
import torchvision.models as models
from easyfsl.methods.utils import evaluate
from torch.optim import SGD, Optimizer
from torch.optim.lr_scheduler import MultiStepLR
from easyfsl.methods import PrototypicalNetworks, FewShotClassifier
from easyfsl.modules import resnet12
from easyfsl.datasets import PLANT
from easyfsl.samplers import TaskSampler
from torch.utils.data import DataLoader
import matplotlib.image as mpimg
from PIL import Image
import matplotlib.pyplot as plt

import warnings
warnings.filterwarnings("ignore")


if torch.cuda.is_available()==True:
    print('GPUs are available! ')
else:
    print('Please configure GPSs are not available')

GPUs are available!


img = mpimg.imread('./data/PLANT/100/DSC05982.jpg')
print(img.shape)
plt.imshow(img)

(256, 256, 3)

<matplotlib.image.AxesImage at 0x1e3f3be6670>


img = mpimg.imread('./data/PLANT/256/DSC09062.jpg')
print(img.shape)
plt.imshow(img)

(256, 256, 3)

<matplotlib.image.AxesImage at 0x1e3f3c65340>


img = mpimg.imread('./data/PLANT/316/DSC03840.jpg')
print(img.shape)
plt.imshow(img)

(256, 256, 3)

<matplotlib.image.AxesImage at 0x1e3f3cdc520>


img = mpimg.imread('./data/PLANT/330/DSC06136.jpg')
print(img.shape)
plt.imshow(img)

(256, 256, 3)

<matplotlib.image.AxesImage at 0x1e3f3d5b4c0>


img = mpimg.imread('./data/PLANT/348/DSC01037.jpg')
print(img.shape)
plt.imshow(img)

(256, 256, 3)

<matplotlib.image.AxesImage at 0x1e3f5dce6d0>


img = mpimg.imread('./data/PLANT/370/DSC01163.jpg')
print(img.shape)
plt.imshow(img)

(256, 256, 3)

<matplotlib.image.AxesImage at 0x1e3f5e41bb0>


images_data = []
for i in os.listdir('./data/PLANT/110/')[0:10]:
    split = i.split('_')
    images_data.append(Image.open('./data/PLANT/110/' + i))
plt.figure(figsize=(10,10))
for i in range(10):
    plt.subplot(5,2,i+1)
    plt.imshow(images_data[i])
plt.show()


images_data = []
for i in os.listdir('./data/PLANT/150/')[0:10]:
    split = i.split('_')
    images_data.append(Image.open('./data/PLANT/150/' + i))
plt.figure(figsize=(10,10))
for i in range(10):
    plt.subplot(5,2,i+1)
    plt.imshow(images_data[i])
plt.show()


images_data = []
for i in os.listdir('./data/PLANT/200/')[0:10]:
    split = i.split('_')
    images_data.append(Image.open('./data/PLANT/200/' + i))
plt.figure(figsize=(10,10))
for i in range(10):
    plt.subplot(5,2,i+1)
    plt.imshow(images_data[i])
plt.show()


images_data = []
for i in os.listdir('./data/PLANT/370/')[0:10]:
    split = i.split('_')
    images_data.append(Image.open('./data/PLANT/370/' + i))
plt.figure(figsize=(10,10))
for i in range(10):
    plt.subplot(5,2,i+1)
    plt.imshow(images_data[i])
plt.show()


n_way = 271 # number of classes
n_shot = 1 #number of samples 
n_query = 1 # Number of images per class in the query set

DEVICE = "cuda"
n_workers = 5


n_tasks_per_epoch = 2000
n_validation_tasks = 2000

train_set = PLANT(split="train", training=True)
val_set = PLANT(split="test", training=False)

train_sampler = TaskSampler(
    train_set, n_way=n_way, n_shot=n_shot, n_query=n_query, n_tasks=n_tasks_per_epoch
)
val_sampler = TaskSampler(
    val_set, n_way=n_way, n_shot=n_shot, n_query=n_query, n_tasks=n_validation_tasks
)


train_loader = DataLoader(
    train_set,
    batch_sampler=train_sampler,
    num_workers=n_workers,
    pin_memory=True,
    collate_fn=train_sampler.episodic_collate_fn,
)


val_loader = DataLoader(
    val_set,
    batch_sampler=val_sampler,
    num_workers=n_workers,
    pin_memory=True,
    collate_fn=val_sampler.episodic_collate_fn,
)


tranfer_learning_model = models.googlenet(pretrained=True)


few_shot_classifier = PrototypicalNetworks(tranfer_learning_model).to(DEVICE)


LOSS_FUNCTION = nn.CrossEntropyLoss()
n_epochs = 50
scheduler_milestones = [20, 30]
scheduler_gamma = 0.1
learning_rate = 1e-2

train_optimizer = SGD(
    few_shot_classifier.parameters(), lr=learning_rate, momentum=0.9, weight_decay=5e-4
)
train_scheduler = MultiStepLR(
    train_optimizer,
    milestones=scheduler_milestones,
    gamma=scheduler_gamma,
)


def training_epoch(
    model: FewShotClassifier, data_loader: DataLoader, optimizer: Optimizer
):
    all_loss = []
    model.train()
    with tqdm(
        enumerate(data_loader), total=len(data_loader), desc="Training"
    ) as tqdm_train:
        for episode_index, (
            support_images,
            support_labels,
            query_images,
            query_labels,
            _,
        ) in tqdm_train:
            optimizer.zero_grad()
            model.process_support_set(
                support_images.to(DEVICE), support_labels.to(DEVICE)
            )
            classification_scores = model(query_images.to(DEVICE))

            loss = LOSS_FUNCTION(classification_scores, query_labels.to(DEVICE))
            loss.backward()
            optimizer.step()

            all_loss.append(loss.item())

            tqdm_train.set_postfix(loss=mean(all_loss))

    return mean(all_loss)


best_state = few_shot_classifier.state_dict()
best_validation_accuracy = 0.0
for epoch in range(n_epochs):
    print(f"Epoch {epoch}")
    average_loss = training_epoch(few_shot_classifier, train_loader, train_optimizer)
    validation_accuracy = evaluate(
        few_shot_classifier, val_loader, device=DEVICE, tqdm_prefix="Validation"
    )

    if validation_accuracy > best_validation_accuracy:
        best_validation_accuracy = validation_accuracy
        best_state = few_shot_classifier.state_dict()
    train_scheduler.step()

Epoch 0

Training: 100%|█████████████████████████████████████████████████████████████| 2000/2000 [00:06<00:00,  2.01it/s, loss=9.31]
Validation: 100%|██████████████████████████████████████████████████████| 2000/2000 [00:02<00:00,  6.11it/s, accuracy=0.241]

Epoch 1

Training: 100%|█████████████████████████████████████████████████████████████| 2000/2000 [00:04<00:00,  3.46it/s, loss=9.24]
Validation: 100%|██████████████████████████████████████████████████████| 2000/2000 [00:05<00:00,  2.61it/s, accuracy=0.242]

Epoch 2

Training: 100%|█████████████████████████████████████████████████████████████| 2000/2000 [00:03<00:00,  3.70it/s, loss=9.77]
Validation: 100%|██████████████████████████████████████████████████████| 2000/2000 [00:05<00:00,  2.50it/s, accuracy=0.244]

Epoch 3

Training: 100%|█████████████████████████████████████████████████████████████| 2000/2000 [00:05<00:00,  2.59it/s, loss=9.43]
Validation: 100%|██████████████████████████████████████████████████████| 2000/2000 [00:05<00:00,  2.73it/s, accuracy=0.246]

Epoch 4

Training: 100%|██████████████████████████████████████████████████████████████| 2000/2000 [00:05<00:00,  2.41it/s, loss=8.94]
Validation: 100%|███████████████████████████████████████████████████████| 2000/2000 [00:05<00:00,  2.52it/s, accuracy=0.247]


few_shot_classifier.load_state_dict(best_state)

<All keys matched successfully>


n_test_tasks = 2000

test_set = PLANT(split="test", training=False)
test_sampler = TaskSampler(
    test_set, n_way=n_way, n_shot=n_shot, n_query=n_query, n_tasks=n_test_tasks
)
test_loader = DataLoader(
    test_set,
    batch_sampler=test_sampler,
    num_workers=n_workers,
    pin_memory=True,
    collate_fn=test_sampler.episodic_collate_fn,
)


accuracy = evaluate(few_shot_classifier, test_loader, device=DEVICE)
print(f"Average accuracy : {(100 * accuracy):.1f} %")

100%|██████████████████████████████████████████████████████████████████| 2000/2000 [00:07<00:00,  1.76it/s, accuracy=0.559]

Average accuracy : 55.9 %

👨‍💻 Getting Started with Few Shot Learning

Importing Python Libraries 📕 📗 📘 📙

Exploratory data analysis 🔎 📊

Sample images¶

Some random Imeges of class 110¶

Some random Imeges of class 150¶

Some random Imeges of class 200¶

Some random Imeges of class 370¶

Training Data

Validation Data

Testing Data

Setting of classes and per class samples.¶

Data Preparation of Training and Validation¶

Training data loader¶

Validation data loader¶

👨Using the Googlenet as transfer learning

Using the tranfser learning in Few Shot Leanring¶

Hyper parameter tuning for the Few Shot Learning model¶

Setting the function of epoch to monitor the real time logs¶

Start training the Few Shot Learning model¶

Using the best model state from the above experimnents¶

Evaluation of trained model using test data¶

Loading the test data using data loader¶

Calculating the accuracy¶